package m

import (
	"sync"

	"GameServer/Common/data"
	"GameServer/Common/utils"
	"GameServer/Game/cache"
	"GameServer/Game/dbmodule"
	"GameServer/Game/errors"

	"github.com/globalsign/mgo/bson"
	log "github.com/sirupsen/logrus"
)

type User struct {
	BaseM
	Uid        bson.ObjectId `bson:"_id" json:"_uid"`
	AccountId  string        `bson:"accountId" json:"accountId"`   // SDK的用户ID
	FaceBookId string        `bson:"faceBookId" json:"faceBookId"` // fb的用户ID
	IdentifId  string        `bson:"identifId" json:"identifId"`   // 玩家唯一标识，从10000-99999999开始，如果不够再增加A0000000，首数字为十六位
	Number     int64         `bson:"number" json:"number"`         //玩家编号
	Name       string        `bson:"name" json:"name"`
	Head       string        `bson:"head" json:"head"`
	Energy     int64         `bson:"energy" json:"energy"`           //体力
	Gold       int64         `bson:"gold" json:"gold"`               //金币
	Diamon     int64         `bson:"diamon" json:"diamon"`           //砖石
	Shield     int64         `bson:"shield" json:"shield"`           //盾牌
	Pos        *PosInfo      `bson:"pos,omitempty" json:"pos"`       // 关卡位置信息
	MaxPos     *PosInfo      `bson:"maxPos,omitempty" json:"maxPos"` // 最大关卡信息
	TheftNum   int64         `bson:"theftNum" json:"theftNum"`       // 被偷窃次数
	FireNum    int64         `bson:"fireNum" json:"fireNum"`         // 放火次数

	LastLoginTime    int64 `bson:"last_login_time" json:"lastLoginTime"`     // 最后登录时间
	OfflineTime      int64 `bson:"offline_time" json:"offlineTime"`          // 离线时间
	LastGameDuration int64 `bson:"lastGameDuration" json:"lastGameDuration"` // 上次游玩时间
	LeaveTime        int64 `bson:"leaveTime" json:"leaveTime"`               // 离开时间 两次登录相隔时间
	LeaveDay         int64 `bson:"leaveDay" json:"leaveDay"`                 // 离开时间 两次登录相隔天数，不精确

	Robot           bool   `bson:"robot" json:"robot"`                     // 是否是机器人
	EnergyTime      int64  `bson:"energyTime" json:"energyTime"`           // 给体力的时间
	NextRecoverTime int64  `bson:"nextRecoverTime" json:"nextRecoverTime"` // 恢复体力时间差
	Status          int64  `bson:"status" json:"status"`                   // 状态 0 正常 1 正在被放火
	BanTime         int64  `bson:"banTime" json:"banTime"`                 // 解禁时间
	SlotNoticeUser  string `bson:"slotNoticeUser" json:"slotNoticeUser"`   // 老虎机通知 玩家对象
	openFireGrid    bool
	FireProtec      bool  `bson:"fireProtec" json:"fireProtec"` // 放火保护
	SlotLv          int64 `bson:"slotLv" json:"slotLv"`         // 老虎机等级
	// 星星分开算
	StarSum        int64 `bson:"starSum" json:"starSum"`               // 星星总数量
	Star           int64 `bson:"star" json:"star"`                     // 额外奖励的星星，每关获得所有星星，额外奖励20个星星。
	StarHero       int64 `bson:"starHero" json:"starHero"`             // 英雄星星
	StarPet        int64 `bson:"starPet" json:"starPet"`               // 宠物星星
	StarMap        int64 `bson:"starMap" json:"starMap"`               // 地图星星
	StarAchiev     int64 `bson:"starAchiev" json:"starAchiev"`         // 成就星星
	StarChangeTime int64 `bson:"starChangeTime" json:"starChangeTime"` // 星星改变时间

	UnionId            string `bson:"unionId" json:"unionId"`       // 公会id
	UnionScore         int64  `bson:"unionScore" json:"unionScore"` // 公会积分
	UnionEnergyReqTime int64  `bson:"unionEnergyReqTime" json:"unionEnergyReqTime"`
	UnionJionTime      int64  `bson:"unionJionTime" json:"unionJionTime"` //加入公会时间
	UnionSignNum       int64  `bson:"unionSignNum" json:"unionSignNum"`   //签到，点击剩余次数
	UnionIntegral      int64  `bson:"unionIntegral" json:"unionIntegral"` //公会签到，每次点击，获得的积分
	UnionCurTime       int64  `bson:"unionCurTime" json:"unionCurTime"`   //公会签到，当前签到凌晨时间

	HandleGoldRate   int64           `bson:"handleGoldRate" json:"handleGoldRate"`     // 拾取金币收益
	TheftGoldRate    int64           `bson:"theftGoldRate" json:"theftGoldRate"`       // 被偷金币损失
	FireGridRate     int64           `bson:"fireGridRate" json:"fireGridRate"`         // 挖焦土消耗金币
	RegisterTime     int64           `bson:"registerTime" json:"registerTime"`         // 注册时间
	Platform         int64           `bson:"platform" json:"platform"`                 // 登录平台
	UsedName         string          `bson:"usedName" json:"usedName"`                 // 曾用名
	AvatarFrame      int64           `bson:"avatarFrame" json:"avatarFrame"`           // 头像框ID-使用中
	AvatarFrameArr   map[int64]int64 `bson:"avatarFrameArr" json:"avatarFrameArr"`     // 头像框ID列表-持有
	UserGroup        int64           `bson:"userGroup" json:"userGroup"`               // 用户分组
	LastSignInTime   int64           `bson:"lastSignInTime" json:"lastSignInTime"`     // 上次签到时间
	ClosureStartTime int64           `bson:"closureStartTime" json:"closureStartTime"` //封禁起始时间
	ClosureEndTime   int64           `bson:"closureEndTime" json:"closureEndTime"`     //封禁结束时间

	LangsTyp            string `bson:"langsTyp" json:"langsTyp"`                       //用户使用的语言
	SuperAccount        int64  `bson:"superAccount" json:"superAccount"`               // 0.非白名单 1.白名单、超级账号
	FirstReChargeStatus int64  `bson:"firstReChargeStatus" json:"firstReChargeStatus"` // 首充奖励状态 0-未达成 1-达成未领取 2-达成并领取

	RenameCd int64 `bson:"RenameCd" json:"RenameCd"` // 更改信息冷却时间戳_未来解禁时间
	rw       sync.RWMutex
}

// 关卡位置信息
type PosInfo struct {
	LockBlockTid     int64 `bson:"lockBlockTid" json:"lockBlockTid"`
	LayerId          int64 `bson:"layerId" json:"layerId"`
	LayerOpenGridNum int64 `bson:"layerOpenGridNum" json:"layerOpenGridNum"`
}

// 物品
type Goods struct {
	Tid int64 `bson:"tid" json:"tid"`
	Num int64 `bson:"num" json:"num"`
}

// 宝箱内的物品
type BoxRes struct {
	Tid int64
	Res []*Goods
}

// 浅赋值
func (u *User) ShallowSet(u1 User) {
	defer u.Update(u)
	u.Energy = u1.Energy
	u.Gold = u1.Gold
	u.Diamon = u1.Diamon
	u.Shield = u1.Shield
	u.SlotLv = u1.SlotLv
	u.Star = u1.Star
	u.EnergyTime = u1.EnergyTime
	u.NextRecoverTime = u1.NextRecoverTime
	u.UnionScore = u1.UnionScore
	u.UnionEnergyReqTime = u1.UnionEnergyReqTime
	u.HandleGoldRate = u1.HandleGoldRate
	u.TheftGoldRate = u1.TheftGoldRate
	u.FireGridRate = u1.FireGridRate
}

func NewUser() cache.EntryI {
	return new(User)
}

func (u *User) Save() (err error) {
	if u.Robot {
		return
	}
	// u.StarSum = u.StarVal() //保存信息时，计算星星，会卡死。
	err = dbmodule.MgoDB.GameDB.Upsert("user", bson.M{"_id": u.Uid}, u)
	if err != nil {
		return
	}
	return
}

func (u *User) Load(key interface{}) (err error) {
	switch key.(type) {
	case string:
		if key.(string) == "" || !bson.IsObjectIdHex(key.(string)) {
			log.WithFields(log.Fields{
				"method": "User_Load",
				"data":   key,
			}).Error("无效的key load")
			return errors.New("无效的key load")
		}
		u.Uid = bson.ObjectIdHex(key.(string))
	case bson.ObjectId:
		u.Uid = key.(bson.ObjectId)
	default:
		log.WithFields(log.Fields{
			"method": "User_Load",
			"data":   key,
		}).Error("无效的key load")
		return errors.New("无效的key load")
	}
	return u.LoadData()
}

// 加载数据
func (u *User) LoadData() (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("user", bson.M{"_id": u.Uid}, nil, u)
	if err != nil {
		if err.Error() == "not found" {
			err = errors.NewErrcode(data.Errcode.UserNotFound, "角色不存在")
			return err
		}
		return
	}
	if u.AvatarFrameArr == nil {
		u.AvatarFrameArr = make(map[int64]int64, 0)
		u.AvatarFrameArr[data.AvatarFrameEnum.DefaultFrame] = data.AvatarFrameEnum.DefaultFrame //默认头像框
	}
	if u.AvatarFrame == 0 {
		u.AvatarFrame = data.AvatarFrameEnum.DefaultFrame //默认头像框
	}
	return
}

// 更新数据
func (u *User) Update(val *User) {
	Cache.Put("user", val.Uid.Hex(), val)
	val.UpdateData()
}

// 初始化
func (u *User) Init(rEnergy int64) (err error) {
	u.CaculEnergy(rEnergy)
	u.HideShop().InitHideShop()
	return
}

func (u *User) FindByName(name string) (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("user", bson.M{"name": name}, nil, u)
	if err != nil {
		err = errors.NewErrcode(data.Errcode.UserNotFound, err.Error())
		return
	}
	return
}

func (u *User) FindByAccountId(accountId string) (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("user", bson.M{"accountId": accountId}, nil, u)
	if err != nil {
		err = errors.NewErrcode(data.Errcode.UserNotFound, err.Error())
		return
	}
	return
}

func (u *User) FindByFaceBookId(facebookId string) (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("user", bson.M{"faceBookId": facebookId}, nil, u)
	if err != nil {
		err = errors.NewErrcode(data.Errcode.UserNotFound, err.Error())
		return
	}
	return
}

func (u *User) FindByIdentifId(identifId string) (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("user", bson.M{"identifId": identifId}, nil, u)
	if err != nil {
		err = errors.NewErrcode(data.Errcode.UserNotFound, err.Error())
		return
	}
	return
}

// 获取玩家数量
// func (u *User) Count() (count int64, err error) {
// 	rcount, err := dbmodule.MgoDB.GameDB.Count("user", nil)
// 	if err != nil {
// 		return
// 	}
// 	count = int64(rcount)
// 	return
// }

// 设置关卡信息
func (u *User) SetLockBlocks(val *LockBlocks) {
	Cache.Put("lockBlock", u.Uid.Hex(), val)
	val.UpdateData()
}

func (u *User) AddGold(from string, val int64) (r *BaseKV) {
	u.rw.Lock()
	defer u.rw.Unlock()
	logData := make(map[string]interface{}, 0)
	logData["val"] = val
	logData["oldGold"] = u.Gold
	u.Gold += val
	r = &BaseKV{Key: data.GlobalEnum.Gold, Val: u.Gold}
	logData["newGold"] = u.Gold
	if from != "CheckCost" {
		log.WithFields(log.Fields{
			"from":   from,
			"uid":    u.Uid.Hex(),
			"method": "AddGold",
			"data":   logData,
		}).Debug("基础数据变更")
	}

	return
}

func (u *User) AddDiamond(from string, val int64) (r *BaseKV) {
	u.rw.Lock()
	defer u.rw.Unlock()
	logData := make(map[string]interface{}, 0)
	logData["val"] = val
	logData["oldDiamon"] = u.Diamon
	u.Diamon += val
	r = &BaseKV{Key: data.GlobalEnum.Diamond, Val: u.Diamon}
	logData["newDiamon"] = u.Diamon
	if from != "CheckCost" {
		log.WithFields(log.Fields{
			"from":   from,
			"uid":    u.Uid.Hex(),
			"method": "AddDiamond",
			"data":   logData,
		}).Debug("基础数据变更")
	}
	return
}

func (u *User) AddEnergy(from string, val int64) (r []*BaseKV) {
	u.rw.Lock()
	defer u.rw.Unlock()
	logData := make(map[string]interface{}, 0)
	logData["val"] = val
	logData["oldEnergy"] = u.Energy

	//当前体力>=50，或者当前体力值+val>=50时，体力时间（起始时间）改为当前时间
	if u.Energy >= 50 || u.Energy+val >= 50 {
		u.EnergyTime = utils.TNow().Unix()
		u.NextRecoverTime = 3600
	}
	//每小时恢复体力
	nextRecoverTime := int64(3600)
	// 宠物加快体力恢复速度
	rateVal := u.GetUserPet().GetSkillVal(uint64(data.PetSkillEffectEnum.FastRestEnergy))
	if rateVal > 0 {
		nextRecoverTime -= int64(float64(3600) * rateVal / 100)
	}

	//恢复体力方法请求时，需重新计算恢复时间差 || 当体力>=50 && 体力+val<50，需计算恢复体力时间差
	if (from == "RestoreEnergyRequest") || (nextRecoverTime < u.NextRecoverTime && u.Energy >= 50 && u.Energy+val < 50) {
		u.NextRecoverTime = nextRecoverTime
	}
	u.Energy += val

	r = append(r, &BaseKV{Key: data.GlobalEnum.Energy, Val: u.Energy})
	r = append(r, &BaseKV{Key: data.GlobalEnum.EnergyTime, Val: u.EnergyTime})
	r = append(r, &BaseKV{Key: data.GlobalEnum.NextRecoverTime, Val: u.NextRecoverTime})
	r = append(r, &BaseKV{Key: data.GlobalEnum.NowTime, Val: utils.TNow().Unix()})

	logData["newEnergy"] = u.Energy
	logData["EnergyTime"] = u.EnergyTime
	logData["NextRecoverTime"] = u.NextRecoverTime
	log.WithFields(log.Fields{
		"from":   from,
		"uid":    u.Uid.Hex(),
		"method": "AddEnergy",
		"data":   logData,
	}).Debug("基础数据变更")
	return
}

func (u *User) AddShield(from string, val int64) (r []*BaseKV) {
	if val > 0 && u.Shield >= 3 {
		return u.AddEnergy(from+"_AddShield", val)
	}
	if u.Shield+val > 3 && val > 0 {
		r = append(r, u.AddEnergy(from+"_AddShield", val-(3-u.Shield))...)
		val = 3 - u.Shield
	}
	logData := make(map[string]interface{}, 0)
	logData["val"] = val
	logData["oldShield"] = u.Shield
	u.Shield += val
	r = append(r, &BaseKV{Key: data.GlobalEnum.Shield, Val: u.Shield})
	logData["newShield"] = u.Shield
	log.WithFields(log.Fields{
		"from":   from,
		"uid":    u.Uid.Hex(),
		"Name":   u.Name,
		"method": "AddShield",
		"data":   logData,
	}).Debug("基础数据变更")
	return
}

func (u *User) AddSlotLv(val int64) (r *BaseKV) {
	u.rw.Lock()
	defer u.rw.Unlock()
	u.SlotLv += val
	r = &BaseKV{Key: data.GlobalEnum.SlotLv, Val: val}
	return
}

func (u *User) AddStarAchiev(val int64) (r *BaseKV) {
	u.rw.Lock()
	defer u.rw.Unlock()
	u.StarAchiev += val
	r = &BaseKV{Key: data.GlobalEnum.Star, Val: val}
	return
}

func (u *User) AddStar(val int64) (r *BaseKV) {
	u.rw.Lock()
	defer u.rw.Unlock()
	u.Star += val
	r = &BaseKV{Key: data.GlobalEnum.Star, Val: val}
	return
}

func (u *User) AddUnionScore(val int64) (r *BaseKV) {
	u.rw.Lock()
	defer u.rw.Unlock()
	u.UnionScore += val
	r = &BaseKV{Key: data.GlobalEnum.Union, Val: val}
	return
}

// 增加玩家持有的头像(不替换) 传入参数，头像id; needCallClient 玩家数据发生变更，需要推给玩家
func (u *User) AddAvatarFrame(val int64) (needCallClient bool, curFrame int64, gainFrameArr map[int64]int64) {
	needCallClient = false
	curFrame = u.AvatarFrame
	u.rw.Lock()
	defer u.rw.Unlock()
	if u.AvatarFrameArr == nil {
		u.AvatarFrameArr = make(map[int64]int64, 0)
		u.AvatarFrameArr[data.AvatarFrameEnum.DefaultFrame] = data.AvatarFrameEnum.DefaultFrame //默认头像框
		needCallClient = true
	}
	// 检查是否是配表有的头像ID
	// 读表
	_, findTheConfig := data.Get("AvatarFrames", uint64(val))
	if findTheConfig == false {
		log.WithFields(log.Fields{
			"method": "AddAvatarFrame",
			"buffId": val,
		}).Error("AvatarFrames读表失败,没有找到该ID的头像框配置")
		return needCallClient, u.AvatarFrame, u.AvatarFrameArr
	}
	//
	_, findFrame := u.AvatarFrameArr[val]
	if findFrame == false {
		u.AvatarFrameArr[val] = val
		u.Update(u)
		needCallClient = true
	}
	return needCallClient, u.AvatarFrame, u.AvatarFrameArr
}

// 删除玩家指定的头像，如果玩家当前正在使用删除头像，则换成默认头像;needCallClient 玩家数据发生变更，需要推给玩家
func (u *User) RemoveAvatarFrame(val int64) (needCallClient bool, curFrame int64, gainFrameArr map[int64]int64) {
	needCallClient = false
	u.rw.Lock()
	defer u.rw.Unlock()
	if u.AvatarFrameArr == nil {
		u.AvatarFrameArr = make(map[int64]int64, 0)
		u.AvatarFrameArr[data.AvatarFrameEnum.DefaultFrame] = data.AvatarFrameEnum.DefaultFrame //默认头像框
		needCallClient = true
		return needCallClient, u.AvatarFrame, u.AvatarFrameArr
	}
	if val == data.AvatarFrameEnum.DefaultFrame { // 不能删除默认头像框
		return needCallClient, u.AvatarFrame, u.AvatarFrameArr
	}
	_, findFrame := u.AvatarFrameArr[val]
	if findFrame {
		delete(u.AvatarFrameArr, val)
		if u.AvatarFrame == val {
			//玩家当前正在使用删除头像，则换成默认头像
			u.AvatarFrame = data.AvatarFrameEnum.DefaultFrame
		}
		needCallClient = true
		u.Update(u)
	}
	return needCallClient, u.AvatarFrame, u.AvatarFrameArr
}

// 更改玩家的头像框，传入参数为id
func (u *User) ChangeAvatarFrame(targetFrameId int64) {
	u.rw.Lock()
	defer u.rw.Unlock()
	_, findFrame := u.AvatarFrameArr[targetFrameId]
	if findFrame {
		u.AvatarFrame = targetFrameId
		u.Update(u)
	}
	return
}

// 设置为默认头像
func (u *User) SetDefaultAvatarFrame() {
	u.rw.Lock()
	defer u.rw.Unlock()
	if u.AvatarFrameArr == nil {
		u.AvatarFrameArr = make(map[int64]int64, 0)
	}
	defaultFrame := data.AvatarFrameEnum.DefaultFrame
	u.AvatarFrameArr[defaultFrame] = defaultFrame //默认头像框
	u.AvatarFrame = defaultFrame
	u.Update(u)
}

// 更改用户名称，头像
func (u *User) ChangeNameAndHead(newName string, newHead string) {
	u.rw.Lock()
	defer u.rw.Unlock()
	usedName := u.Name
	u.Name = newName
	u.Head = newHead
	u.UsedName = usedName
	u.Update(u)
	return
}

// 更改用户登录平台类型
func (u *User) ChangePlatform(newPlatform int64) {
	u.rw.Lock()
	defer u.rw.Unlock()
	u.Platform = newPlatform
	u.Update(u)
	return
}

// 更改登录平台，同时更改,名字,头像,facebookId
func (u *User) ChangePlatformAndNameHead(newPlatform int64, newName string, newHead string, faceBookId string) {
	u.rw.Lock()
	defer u.rw.Unlock()
	usedName := u.Name
	u.Name = newName
	u.Head = newHead
	u.UsedName = usedName
	u.Platform = newPlatform
	u.FaceBookId = faceBookId
	u.Update(u)
	return
}

// 更改用户分组
func (u *User) ChangeUserGroup(newGroup int64) {
	u.rw.Lock()
	// fmt.Printf("[m.User]玩家[%s]尝试修改用户分组[%d]->[%d]\n", u.Name, u.UserGroup, newGroup)
	u.UserGroup = newGroup
	// Cache.Put("user", u.Uid.Hex(), u)
	// u.UpdateData()
	u.Update(u)
	u.rw.Unlock()
	// u.Save()
	return
}

// 更改上次签到时间
func (u *User) ChangeLastSignInTime(newTime int64) {
	u.rw.Lock()
	defer u.rw.Unlock()
	u.LastSignInTime = newTime
	u.Update(u)
	return
}

// 计算并恢复 的体力 初始化用户数据才调用，用户登录计算体力。
func (u *User) CaculEnergy(rEnergy int64) {
	//初始化恢复体力时间差
	u.NextRecoverTime = int64(3600)

	now := utils.TNow().Unix()
	tnum := now - u.EnergyTime //现在时间-体力时间=时间差
	if tnum <= 0 {
		return
	}
	pret := tnum / 3600 //几个小时
	if pret <= 0 {
		return
	}
	num := pret * rEnergy //每小时增加5点体力
	if u.Energy >= 50 {   //当前体力>=50 不恢复体力
		u.EnergyTime = now
		return
	}
	if u.Energy+num > 50 { //当前体力+时间恢复体力>50
		u.EnergyTime = now
		num = 50 - u.Energy
	} else { //当前体力+时间恢复体力<=50
		lessTime := tnum % 3600       //增加体力用掉的时间，计算未用的时间
		u.EnergyTime = now - lessTime //当前时间-未用掉的时间
	}
	u.AddEnergy("CaculEnergy", num)
}

func (u *User) StarVal() (r int64) {
	u.StarSum = u.Star + u.StarMap + u.StarHero + u.StarPet + u.StarAchiev
	return u.StarSum
}

// 玩家被放火
func (u *User) FireIng() {
	defer u.Update(u)
	u.Status = 1
}

// 解除放火
func (u *User) UnFire() {
	defer u.Update(u)
	u.Status = 0
}

//增加被偷盗次数
func (u *User) AddTheftNum() {
	defer u.Update(u)
	u.TheftNum += 1
}

// 增加被放火次数
func (u *User) AddFireNum() {
	defer u.Update(u)
	u.FireNum += 1
}

// 设置老虎机通知对象
func (u *User) SetSlotNoticeUser(uid string) {
	defer u.Update(u)
	u.SlotNoticeUser = uid
}

// 上线
func (u *User) OnLine() {
	defer u.Update(u)

	nowTime := utils.TNow()
	nowTimeStamp := nowTime.Unix()
	if u.LastLoginTime == 0 {
		u.LeaveTime = 0
		u.LeaveDay = 0
	} else {
		// 回归时间
		u.LeaveTime = nowTimeStamp - u.LastLoginTime
		// 回归天数
		sameDay := utils.IsSameDay(nowTimeStamp, u.LastLoginTime)
		if sameDay {
			u.LeaveDay = 0
		} else {
			last_zeroTime := utils.ZeroTime(utils.TTime(u.LastLoginTime, 0))
			now_zeroTime := utils.ZeroTime(nowTime)
			offsetTime := now_zeroTime - last_zeroTime
			if offsetTime > 0 {
				u.LeaveDay = int64(float64(offsetTime) / float64(86400))
			} else {
				u.LeaveDay = 0
			}
		}
	}

	u.OfflineTime = 0
	u.LastLoginTime = nowTimeStamp //utils.TNow().Unix()
	u.TheftNum = 0
	u.FireNum = 0
	// 清空神秘商店交互次数
	userHideShop := u.HideShop()
	if userHideShop != nil {
		userHideShop.SetFireNum(0)
	}
}

// 离线
func (u *User) OffLine() {
	defer u.Update(u)
	nowTime := utils.TNow().Unix()
	u.OfflineTime = nowTime
	u.LastGameDuration = nowTime - u.LastLoginTime
}

// 玩家离线，返回true。
func (u *User) IsOffLine() bool {
	return u.OfflineTime > 0
}

// 玩家在线，返回true。
func (u *User) IsOnLine() bool {
	return u.OfflineTime == 0
}

//
// func (u *User) OpenFireGrid() {
// 	u.openFireGrid = true
// }

// 是否开启了 格子
// func (u *User) IsOpenFireGrid() bool {
// 	return u.openFireGrid
// }

// 移除放火保护
// func (u *User) RemoveFireProtec() {
// 	defer u.Update(u)
// 	u.FireProtec = false
// }

// 增加放火保护
// func (u *User) AddFireProtec() {
// 	defer u.Update(u)
// 	u.FireProtec = true
// }

// 设置封禁时间
func (u *User) ClosureTime(closureLength int64) {
	defer u.Update(u)
	nTime := utils.TNow().Unix()             //现在时间戳
	u.ClosureStartTime = nTime               //封禁起始时间
	u.ClosureEndTime = nTime + closureLength //封禁结束时间
}

// 设置封禁时间
func (u *User) ClosureETime(closureEndTime int64) {
	defer u.Update(u)
	u.ClosureStartTime = utils.TNow().Unix() //封禁起始时间
	u.ClosureEndTime = closureEndTime        //封禁结束时间
}

// 修改超级管理员
func (u *User) ModifySuperAccount(superAccount int64) {
	defer u.Update(u)
	u.SuperAccount = superAccount //封禁起始时间
}

func GetUser(uid string) (r *User) {
	v, _ := Cache.Get("user", uid)
	r = v.(*User)
	return
}

// 设置首充奖励状态 0-未达成 1-达成未领取 2-达成并领取
func (u *User) SetFirstRechargeStatus(status int64) {
	u.rw.Lock()
	defer u.rw.Unlock()
	u.FirstReChargeStatus = status
	u.Update(u)
	return
}

func (this *User) ResetUnionEnergyReqTime() {
	this.UnionEnergyReqTime = utils.TNow().Unix() + 3600*6
	this.Update(this)
}
